package com.jse.util;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.regex.Pattern;

public class Nums {

	public static final Pattern INT_REGEX = Pattern.compile("[0-9]+");
	public static final Pattern INTEGER_REGEX = Pattern.compile("^[-\\+]?[\\d]*$");  
	/**
	 * 正负数
	 * @param str
	 * @return
	 */
	public static boolean isInt(String str) {  
        return INT_REGEX.matcher(str).matches();  
	}
	/**
	 * 正负数
	 * @param str
	 * @return
	 */
	public static boolean isInteger(String str) {  
        return INTEGER_REGEX.matcher(str).matches();  
	}
		
		/** 人民币0-9 */
	    public static String[] _RMB_NUM_ = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
	    /** 人民币单位 */
	    public static String[] _RMB_UNIT_ = {"圆", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾","佰", "仟"};
	    /** 人民币小数单位 */
	    public static String[] _RMB_DEC_ = {"角", "分"};
	    public static String AMOUNT_2R = "^(0|[\\+\\-]?[1-9]\\d*)(\\.\\d{1,2})?$";//标准元金额，支持0-2位小数，支持正负数
	    /**
	     * 金额分，转为字符串元，转化后是2位小数点
	     * 
	     * @param fen   金额分值，能转化成长整型的字符串
	     * @return      金额元值字符串
	     */
	    public static String toYuan(String fen)
	    {
	        return toYuan(Long.parseLong(fen));
	    }
	    
	    /**
	     * 金额分，转为字符串元，转化后最大2位小数点，没有的不保留小数点（0.##）
	     * 
	     * @param fen   金额分值
	     * @return      金额元值字符串
	     */
	    public static String toYuan(long fen)
	    {
	        return new DecimalFormat("0.##").format((double)fen / 100);
	    }
	    
	    /**
	     * 金额分，转为字符串元，转化后强制为2位小数点，没有的为（0.00）
	     * 
	     * @param fen   金额分值
	     * @return      金额元值字符串
	     */
	    public static String toYuanMustRadix(String fen)
	    {
	        return toYuanMustRadix(Long.parseLong(fen));
	    }
	    
	    /**
	     * 金额分，转为字符串元，转化后强制为2位小数点，没有的为（0.00）
	     * 
	     * @param fen   金额分值
	     * @return      金额元值字符串，如"2.00"
	     */
	    public static String toYuanMustRadix(long fen)
	    {
	        return new DecimalFormat("0.00").format((double)fen / 100);
	    }
	    
	    
	    /**
	     * 金额元字符串转int金额分，支持整数、1位小数和2位小数点的金额字符串
	     * 
	     * @param yuan          金额元的字符串
	     * @param defaultValue  缺省值
	     * @return              金额分整型
	     */
	    public static int toFen(String yuan, int defaultValue)
	    {
	        if (yuan == null)
	            return defaultValue;
	        
	        if (!Regexs.match(AMOUNT_2R, yuan))
	            return defaultValue;
	        
	        boolean isNegative = false;
	        if (yuan.startsWith("-"))
	        {
	            isNegative = true;
	            yuan = yuan.substring(1);
	        }
	        
	        int index = yuan.indexOf('.');
	        if (index == -1)
	        {
	            int value = Integer.parseInt(yuan) * 100;//由元转为分
	            return (isNegative)?-value:value;
	        }
	        
	        int integer = Integer.parseInt(yuan.substring(0, index)) * 100;
	        String radixString = yuan.substring(index + 1);
	        if (radixString.length() == 0)
	        {
	            return (isNegative)?-integer:integer;
	        }
	        else if (radixString.length() == 1)
	        {
	            int radix = Integer.parseInt(radixString);
	            int value = integer + radix * 10;
	            return (isNegative)?-value:value;
	        }
	        else
	        {
	            int radix = Integer.parseInt(radixString);
	            int value = integer + radix;
	            return (isNegative)?-value:value;
	        }
	    }
	    
	    /**
	     * 金额元字符串转long金额分，支持整数、1位小数和2位小数点的金额字符串
	     * 
	     * @param yuan          金额元的字符串
	     * @param defaultValue  缺省值
	     * @return              金额分的长整型
	     */
	    public static long toFen(String yuan, long defaultValue)
	    {
	        if (yuan == null)
	            return defaultValue;
	        
	        if (!Regexs.match(AMOUNT_2R, yuan))
	            return defaultValue;
	        
	        boolean isNegative = false;
	        if (yuan.startsWith("-"))
	        {
	            isNegative = true;
	            yuan = yuan.substring(1);
	        }
	        
	        int index = yuan.indexOf('.');
	        if (index == -1)
	        {
	            long value = Long.parseLong(yuan) * 100;//由元转为分
	            return (isNegative)?-value:value;
	        }
	        
	        long integer = Long.parseLong(yuan.substring(0, index)) * 100;
	        String radixString = yuan.substring(index + 1);
	        if (radixString.length() == 0)
	        {
	            return (isNegative)?-integer:integer;
	        }
	        else if (radixString.length() == 1)
	        {
	            long radix = Long.parseLong(radixString);
	            long value = integer + radix * 10;
	            return (isNegative)?-value:value;
	        }
	        else
	        {
	            long radix = Long.parseLong(radixString);
	            long value = integer + radix;
	            return (isNegative)?-value:value;
	        }
	    }
	    
	    /** 
	     * 获取中文大写金额值 
	     * 
	     * @param value 单位为分的金额值
	     */
	    public static String toChinese(int value) 
	    {
	        Integer in = new Integer(value);
	        double src = in.doubleValue();
	        src = src/100;
	        
	        StringBuilder sb = new StringBuilder();
	        DecimalFormat df = new DecimalFormat("0.00");
	        String srcText = df.format(src);
	        String numText = srcText.substring(0, srcText.length() - 3);
	        String decText = srcText.substring(srcText.length() - 2);

	        int numlen = numText.length();
	        for (int k = 0; k < numlen; k++) 
	        {
	            sb.append(_RMB_NUM_[Integer.parseInt(String.valueOf(srcText.charAt(k)))]);
	            sb.append(_RMB_UNIT_[numlen - k - 1]);
	        }
	        if ("00".equals(decText))
	        {
	            sb.append("整");
	        } 
	        else
	        {
	            sb.append(_RMB_NUM_[Integer.parseInt(String.valueOf(decText.charAt(0)))]);
	            sb.append(_RMB_DEC_[0]);
	            sb.append(_RMB_NUM_[Integer.parseInt(String.valueOf(decText.charAt(1)))]);
	            sb.append(_RMB_DEC_[1]);
	        }
	        String result = sb.toString();
	        result = result.replace("零分", "");
	        result = result.replace("零角", "零");
	        result = result.replace("零仟", "零");
	        result = result.replace("零佰", "零");
	        result = result.replace("零拾", "零");
	        result = result.replace("零圆", "圆");
	        while (true)
	        {
	            String r = result.replace("零零", "零");
	            if (r.equals(result))
	            {
	                break;
	            } 
	            else 
	            {
	                result = r;
	            }
	        }
	        result = result.replace("零圆", "圆");
	        result = result.replace("零万", "万");
	        result = result.replace("零亿", "亿");
	        result = result.replace("亿万", "亿");
	        if(result.startsWith("圆"))
	        {
	            result="零"+result;
	        }
	        return result;
	    }
	    
	    /**
	     * 通过原价和促销价，求折扣
	     * 
	     * @param price     原价
	     * @param priceNew  促销价
	     * @return 返回减钱折扣值，如9.92折,10折
	     */
	    public static String toDiscount(String price, String priceNew)
	    {
	        long priceLong = toFen(price, 0);
	        long priceNewLong = toFen(priceNew, 0);
	        return toDiscount(priceLong, priceNewLong);
	    }
	    
	    /**
	     * 通过原价和促销价，求折扣
	     * 
	     * @param price     原价
	     * @param priceNew  促销价
	     * @return 返回减钱折扣值，如9.92折,10折
	     */
	    public static String toDiscount(long price, long priceNew)
	    {
	        long priceSave = price - priceNew;
	        if (priceSave == 0)
	            return "10";
	        else
	            return toYuan(priceNew * 1000 / price);
	    }
	    
	    //人民币符号
	    public static final String RMB = "￥";


	    /**
	     * 转千位符 无小数位去除小数
	     *
	     * @param num
	     * @return
	     */
	    public static String num(String num) {
	        String numStr = "";
	        if (Strings.isEmpty(num)) {
	            return numStr;
	        }

	        NumberFormat nf = NumberFormat.getInstance();
	        try {
	            DecimalFormat df = new DecimalFormat("#,##0");
	            numStr = df.format(nf.parse(num));
	        } catch (ParseException e) {
	            e.printStackTrace();
	        }
	        return numStr;

	    }

	    /**
	     * 转千位符 无小数位去除小数
	     *
	     * @param bdNum
	     * @return
	     */
	    public static String num(BigDecimal bdNum) {
	        String numStr = "";
	        String num = getNum(bdNum);
	        NumberFormat nf = NumberFormat.getInstance();
	        try {
	            BigDecimal bigDecimal = new BigDecimal(num);
	            if ((bigDecimal.doubleValue() % 1) > 0) {
	                DecimalFormat df = new DecimalFormat("#,##0.00");
	                numStr = df.format(nf.parse(num));
	            } else {
	                DecimalFormat df = new DecimalFormat("#,##0");
	                numStr = df.format(nf.parse(num));
	            }
	        } catch (ParseException e) {
	            e.printStackTrace();
	        }
	        return numStr;

	    }

	    /**
	     * 转千位符 保留两位小数
	     *
	     * @param num
	     * @return
	     */
	    public static String num2(String num) {
	        String numStr = "";
	        if (Strings.isEmpty(num)) {
	            return numStr;
	        }
	        NumberFormat nf = NumberFormat.getInstance();
	        try {
	            DecimalFormat df = new DecimalFormat("#,##0.00");
	            numStr = df.format(nf.parse(num));
	        } catch (ParseException e) {
	            e.printStackTrace();
	        }
	        return numStr;
	    }


	    /**
	     * BigDecimal转String
	     *
	     * @param bd
	     * @return
	     */
	    public static String getNum(BigDecimal bd) {
	        if (bd == null) {
	            return new BigDecimal(BigInteger.ZERO).toString();
	        }
	        return bd.toString();
	    }

	    /**
	     * BigDecimal转Float
	     *
	     * @param bd
	     * @return
	     */
	    public static Float getNumByFloat(BigDecimal bd) {
	        if (bd == null) {
	            return new BigDecimal(BigInteger.ZERO).floatValue();
	        }
	        return bd.floatValue();
	    }

	    /**
	     * BigDecimal转String 保留小数
	     *
	     * @param bd
	     * @param v
	     * @return
	     */
	    public static String getNum(BigDecimal bd, int v) {
	        if (bd == null) {
	            return new BigDecimal(BigInteger.ZERO).setScale(v, RoundingMode.HALF_UP).toString();
	        }
	        return bd.setScale(v, RoundingMode.HALF_UP).toString();
	    }
	    
	    /**
		 * 把给定的总数平均分成N份，返回每份的个数<br>
		 * 当除以分数有余数时每份+1
		 *
		 * @param total     总数
		 * @param partCount 份数
		 * @return 每份的个数
		 * @since 4.0.7
		 */
		public static int partValue(int total, int partCount) {
			return partValue(total, partCount, true);
		}

		/**
		 * 把给定的总数平均分成N份，返回每份的个数<br>
		 * 如果isPlusOneWhenHasRem为true，则当除以分数有余数时每份+1，否则丢弃余数部分
		 *
		 * @param total               总数
		 * @param partCount           份数
		 * @param isPlusOneWhenHasRem 在有余数时是否每份+1
		 * @return 每份的个数
		 * @since 4.0.7
		 */
		public static int partValue(int total, int partCount, boolean isPlusOneWhenHasRem) {
			int partValue = total / partCount;
			if (isPlusOneWhenHasRem && total % partCount == 0) {
				partValue++;
			}
			return partValue;
		}
		
		/**
		 * 提供精确的乘法运算
		 *
		 * @param v1 被乘数
		 * @param v2 乘数
		 * @return 积
		 */
		public static double mul(float v1, float v2) {
			return mul(Float.toString(v1), Float.toString(v2)).doubleValue();
		}

		/**
		 * 提供精确的乘法运算
		 *
		 * @param v1 被乘数
		 * @param v2 乘数
		 * @return 积
		 */
		public static double mul(float v1, double v2) {
			return mul(Float.toString(v1), Double.toString(v2)).doubleValue();
		}

		/**
		 * 提供精确的乘法运算
		 *
		 * @param v1 被乘数
		 * @param v2 乘数
		 * @return 积
		 */
		public static double mul(double v1, float v2) {
			return mul(Double.toString(v1), Float.toString(v2)).doubleValue();
		}

		/**
		 * 提供精确的乘法运算
		 *
		 * @param v1 被乘数
		 * @param v2 乘数
		 * @return 积
		 */
		public static double mul(double v1, double v2) {
			return mul(Double.toString(v1), Double.toString(v2)).doubleValue();
		}

		/**
		 * 提供精确的乘法运算<br>
		 * 如果传入多个值为null或者空，则返回0
		 *
		 * @param v1 被乘数
		 * @param v2 乘数
		 * @return 积
		 */
		public static double mul(Double v1, Double v2) {
			//noinspection RedundantCast
			return mul((Number) v1, (Number) v2).doubleValue();
		}

		/**
		 * 提供精确的乘法运算<br>
		 * 如果传入多个值为null或者空，则返回0
		 *
		 * @param v1 被乘数
		 * @param v2 乘数
		 * @return 积
		 */
		public static BigDecimal mul(Number v1, Number v2) {
			return mul(new Number[]{v1, v2});
		}

		/**
		 * 提供精确的乘法运算<br>
		 * 如果传入多个值为null或者空，则返回0
		 *
		 * @param values 多个被乘值
		 * @return 积
		 * @since 4.0.0
		 */
		public static BigDecimal mul(Number... values) {
			if (Lang.isEmpty(values)) {
				return BigDecimal.ZERO;
			}

			Number value = values[0];
			BigDecimal result = new BigDecimal(null == value ? "0" : value.toString());
			for (int i = 1; i < values.length; i++) {
				value = values[i];
				result = result.multiply(new BigDecimal(null == value ? "0" : value.toString()));
			}
			return result;
		}

		/**
		 * 提供精确的乘法运算
		 *
		 * @param v1 被乘数
		 * @param v2 乘数
		 * @return 积
		 * @since 3.0.8
		 */
		public static BigDecimal mul(String v1, String v2) {
			return mul(new BigDecimal(v1), new BigDecimal(v2));
		}

		/**
		 * 提供精确的乘法运算<br>
		 * 如果传入多个值为null或者空，则返回0
		 *
		 * @param values 多个被乘值
		 * @return 积
		 * @since 4.0.0
		 */
		public static BigDecimal mul(String... values) {
			if (Lang.isEmpty(values)) {
				return BigDecimal.ZERO;
			}

			String value = values[0];
			BigDecimal result = new BigDecimal(null == value ? "0" : value);
			for (int i = 1; i < values.length; i++) {
				value = values[i];
				if (null != value) {
					result = result.multiply(new BigDecimal(value));
				}
			}
			return result;
		}
		
		/**
		 * 提供精确的乘法运算<br>
		 * 如果传入多个值为null或者空，则返回0
		 *
		 * @param values 多个被乘值
		 * @return 积
		 * @since 4.0.0
		 */
		public static BigDecimal mul(BigDecimal... values) {
			if (Lang.isEmpty(values)) {
				return BigDecimal.ZERO;
			}

			BigDecimal value = values[0];
			BigDecimal result = null == value ? BigDecimal.ZERO : value;
			for (int i = 1; i < values.length; i++) {
				value = values[i];
				if (null != value) {
					result = result.multiply(value);
				}
			}
			return result;
		}
		
		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
		 *
		 * @param v1 被除数
		 * @param v2 除数
		 * @return 两个参数的商
		 */
		public static double div(float v1, float v2) {
			return div(v1, v2, 10);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
		 *
		 * @param v1 被除数
		 * @param v2 除数
		 * @return 两个参数的商
		 */
		public static double div(float v1, double v2) {
			return div(v1, v2, 10);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
		 *
		 * @param v1 被除数
		 * @param v2 除数
		 * @return 两个参数的商
		 */
		public static double div(double v1, float v2) {
			return div(v1, v2, 10);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
		 *
		 * @param v1 被除数
		 * @param v2 除数
		 * @return 两个参数的商
		 */
		public static double div(double v1, double v2) {
			return div(v1, v2, 10);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
		 *
		 * @param v1 被除数
		 * @param v2 除数
		 * @return 两个参数的商
		 */
		public static double div(Double v1, Double v2) {
			return div(v1, v2, 10);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
		 *
		 * @param v1 被除数
		 * @param v2 除数
		 * @return 两个参数的商
		 * @since 3.1.0
		 */
		public static BigDecimal div(Number v1, Number v2) {
			return div(v1, v2, 10);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况的时候,精确到小数点后10位,后面的四舍五入
		 *
		 * @param v1 被除数
		 * @param v2 除数
		 * @return 两个参数的商
		 */
		public static BigDecimal div(String v1, String v2) {
			return div(v1, v2, 10);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
		 *
		 * @param v1    被除数
		 * @param v2    除数
		 * @param scale 精确度，如果为负值，取绝对值
		 * @return 两个参数的商
		 */
		public static double div(float v1, float v2, int scale) {
			return div(v1, v2, scale, RoundingMode.HALF_UP);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
		 *
		 * @param v1    被除数
		 * @param v2    除数
		 * @param scale 精确度，如果为负值，取绝对值
		 * @return 两个参数的商
		 */
		public static double div(float v1, double v2, int scale) {
			return div(v1, v2, scale, RoundingMode.HALF_UP);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
		 *
		 * @param v1    被除数
		 * @param v2    除数
		 * @param scale 精确度，如果为负值，取绝对值
		 * @return 两个参数的商
		 */
		public static double div(double v1, float v2, int scale) {
			return div(v1, v2, scale, RoundingMode.HALF_UP);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
		 *
		 * @param v1    被除数
		 * @param v2    除数
		 * @param scale 精确度，如果为负值，取绝对值
		 * @return 两个参数的商
		 */
		public static double div(double v1, double v2, int scale) {
			return div(v1, v2, scale, RoundingMode.HALF_UP);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
		 *
		 * @param v1    被除数
		 * @param v2    除数
		 * @param scale 精确度，如果为负值，取绝对值
		 * @return 两个参数的商
		 */
		public static double div(Double v1, Double v2, int scale) {
			return div(v1, v2, scale, RoundingMode.HALF_UP);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
		 *
		 * @param v1    被除数
		 * @param v2    除数
		 * @param scale 精确度，如果为负值，取绝对值
		 * @return 两个参数的商
		 * @since 3.1.0
		 */
		public static BigDecimal div(Number v1, Number v2, int scale) {
			return div(v1, v2, scale, RoundingMode.HALF_UP);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
		 *
		 * @param v1    被除数
		 * @param v2    除数
		 * @param scale 精确度，如果为负值，取绝对值
		 * @return 两个参数的商
		 */
		public static BigDecimal div(String v1, String v2, int scale) {
			return div(v1, v2, scale, RoundingMode.HALF_UP);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
		 *
		 * @param v1           被除数
		 * @param v2           除数
		 * @param scale        精确度，如果为负值，取绝对值
		 * @param roundingMode 保留小数的模式 {@link RoundingMode}
		 * @return 两个参数的商
		 */
		public static double div(float v1, float v2, int scale, RoundingMode roundingMode) {
			return div(Float.toString(v1), Float.toString(v2), scale, roundingMode).doubleValue();
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
		 *
		 * @param v1           被除数
		 * @param v2           除数
		 * @param scale        精确度，如果为负值，取绝对值
		 * @param roundingMode 保留小数的模式 {@link RoundingMode}
		 * @return 两个参数的商
		 */
		public static double div(float v1, double v2, int scale, RoundingMode roundingMode) {
			return div(Float.toString(v1), Double.toString(v2), scale, roundingMode).doubleValue();
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
		 *
		 * @param v1           被除数
		 * @param v2           除数
		 * @param scale        精确度，如果为负值，取绝对值
		 * @param roundingMode 保留小数的模式 {@link RoundingMode}
		 * @return 两个参数的商
		 */
		public static double div(double v1, float v2, int scale, RoundingMode roundingMode) {
			return div(Double.toString(v1), Float.toString(v2), scale, roundingMode).doubleValue();
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
		 *
		 * @param v1           被除数
		 * @param v2           除数
		 * @param scale        精确度，如果为负值，取绝对值
		 * @param roundingMode 保留小数的模式 {@link RoundingMode}
		 * @return 两个参数的商
		 */
		public static double div(double v1, double v2, int scale, RoundingMode roundingMode) {
			return div(Double.toString(v1), Double.toString(v2), scale, roundingMode).doubleValue();
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
		 *
		 * @param v1           被除数
		 * @param v2           除数
		 * @param scale        精确度，如果为负值，取绝对值
		 * @param roundingMode 保留小数的模式 {@link RoundingMode}
		 * @return 两个参数的商
		 */
		public static double div(Double v1, Double v2, int scale, RoundingMode roundingMode) {
			//noinspection RedundantCast
			return div((Number) v1, (Number) v2, scale, roundingMode).doubleValue();
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
		 *
		 * @param v1           被除数
		 * @param v2           除数
		 * @param scale        精确度，如果为负值，取绝对值
		 * @param roundingMode 保留小数的模式 {@link RoundingMode}
		 * @return 两个参数的商
		 * @since 3.1.0
		 */
		public static BigDecimal div(Number v1, Number v2, int scale, RoundingMode roundingMode) {
			return div(v1.toString(), v2.toString(), scale, roundingMode);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
		 *
		 * @param v1           被除数
		 * @param v2           除数
		 * @param scale        精确度，如果为负值，取绝对值
		 * @param roundingMode 保留小数的模式 {@link RoundingMode}
		 * @return 两个参数的商
		 */
		public static BigDecimal div(String v1, String v2, int scale, RoundingMode roundingMode) {
			return div(new BigDecimal(v1), new BigDecimal(v2), scale, roundingMode);
		}

		/**
		 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
		 *
		 * @param v1           被除数
		 * @param v2           除数
		 * @param scale        精确度，如果为负值，取绝对值
		 * @param roundingMode 保留小数的模式 {@link RoundingMode}
		 * @return 两个参数的商
		 * @since 3.0.9
		 */
		public static BigDecimal div(BigDecimal v1, BigDecimal v2, int scale, RoundingMode roundingMode) {
			if (null == v1) {
				return BigDecimal.ZERO;
			}
			if (scale < 0) {
				scale = -scale;
			}
			return v1.divide(v2, scale, roundingMode);
		}
}
